/**
 * 分析数据管理器
 * 
 * 用途：协调蓝牙数据的发送和分析结果的获取，管理数据分析流程
 * 方法：通过AnalysisApiClient与分析服务端通信，处理数据分析请求
 * 原理：
 * - 接收蓝牙脑波数据
 * - 发送数据到分析服务端
 * - 获取并处理分析结果
 * - 提供状态管理和错误处理
 */
package com.example.brain_wave.data

import android.util.Log
import com.example.brain_wave.api.AnalysisApiClient
import com.example.brain_wave.api.model.TabletBrainWaveResponse
import com.example.brain_wave.ui.components.BrainWaveDataPoint
import com.example.brain_wave.ui.components.BrainWaveDataGenerator
import com.example.brain_wave.ui.components.NeuroSkyRawDataPoint
import com.example.brain_wave.ui.components.UserState
import com.example.brain_wave.config.AppConfig
import android.content.Context
import kotlinx.coroutines.*
import java.util.UUID

/**
 * 分析数据管理器状态
 */
enum class AnalysisDataManagerState {
    IDLE,           // 空闲状态
    GENERATING,     // 生成数据中
    SENDING,        // 发送数据中
    PROCESSING,     // 处理结果中（替代轮询状态）
    ERROR           // 错误状态
}

/**
 * 分析数据管理器
 */
class AnalysisDataManager(private val context: Context) {
    
    // API客户端
    private val analysisApiClient = AnalysisApiClient(context)
    private val appConfig = AppConfig.getInstance(context) 
    // 状态管理
    private var currentState = AnalysisDataManagerState.IDLE
    private var isRunning = false
    private var dataGenerationJob: Job? = null
    
    // 会话信息
    private var sessionId: String = ""
    private var roomId: String? = null
    private var userId: String? = null
    
    // 回调函数
    private var onStateChanged: ((AnalysisDataManagerState) -> Unit)? = null
    private var onDataPointGenerated: ((BrainWaveDataPoint) -> Unit)? = null
    private var onAnalysisResult: ((TabletBrainWaveResponse) -> Unit)? = null
    private var onError: ((String) -> Unit)? = null
    
    /**
     * 初始化配置 - 简化版，不生成假sessionId
     */
    fun initialize(
        baseUrl: String,
        roomId: String,
        userId: String? = null
    ) {
        // 不再生成临时sessionId，等待真实会话创建
        this.sessionId = ""
        this.roomId = roomId
        this.userId = userId
        
        // 配置API客户端
        analysisApiClient.setBaseUrl(baseUrl)
        
        // 设置API客户端回调
        analysisApiClient.setOnDataSent { response ->
            println("📤 数据发送成功: $response")
        }
        
        analysisApiClient.setOnAnalysisResult { result ->
            println("📊 收到分析结果: success=${result.success}, sleepStage=${result.sleepStage}")
            updateState(AnalysisDataManagerState.PROCESSING)
            onAnalysisResult?.invoke(result)
        }
        
        analysisApiClient.setOnError { error ->
            Log.e("AnalysisDataManager", "❌ API错误: $error")
            updateState(AnalysisDataManagerState.ERROR)
            onError?.invoke(error)
        }
        
        println("🔧 AnalysisDataManager初始化完成: roomId=$roomId, baseurl=$baseUrl, 等待真实sessionId")
    }
    
    /**
     * 更新会话ID（当从SessionManager获取到真实会话ID时调用）
     */
    fun updateSessionId(sessionId: String) {
        println("🆔 updateSessionId调用 - 旧sessionId='${this.sessionId}', 新sessionId='$sessionId'")
        
        this.sessionId = sessionId
        println("🆔 更新会话ID: $sessionId")
        
        // 不再自动启动数据流程，只是更新sessionId
        // 数据发送将在有真实数据时通过sendRawDataToServer直接进行
    }
    
    /**
     * 设置状态变化回调
     */
    fun setOnStateChanged(callback: (AnalysisDataManagerState) -> Unit) {
        onStateChanged = callback
    }
    
    /**
     * 设置数据点生成回调
     */
    fun setOnDataPointGenerated(callback: (BrainWaveDataPoint) -> Unit) {
        onDataPointGenerated = callback
    }
    
    /**
     * 设置分析结果回调
     */
    fun setOnAnalysisResult(callback: (TabletBrainWaveResponse) -> Unit) {
        onAnalysisResult = callback
    }
    
    /**
     * 设置错误回调
     */
    fun setOnError(callback: (String) -> Unit) {
        onError = callback
    }
    
    /**
     * 开始数据流程 - 简化版，只有在有真实sessionId时才启动
     */
    fun startDataFlow() {
        println("🔍 startDataFlow调用 - sessionId='$sessionId', currentState=$currentState")
        
        // 检查是否有真实的sessionId
        if (sessionId.isEmpty()) {
            Log.w("AnalysisDataManager", "⏸️ 等待真实sessionId，暂不启动数据流程")
            return
        }
        
        if (isRunning) {
            println("⚠️ 数据流程已在运行中")
            return
        }
        
        isRunning = true
        updateState(AnalysisDataManagerState.GENERATING)
        println("▶️ 数据流程已启动 - sessionId=$sessionId")
    }
    
    /**
     * 停止数据流程
     */
    fun stopDataFlow() {
        println("🛑 stopDataFlow调用 - isRunning=$isRunning")
        
        if (!isRunning) {
            Log.w("AnalysisDataManager", "⚠️ 数据流程未在运行")
            return
        }
        
        isRunning = false
        dataGenerationJob?.cancel()
        dataGenerationJob = null
        
        // 移除轮询停止调用，因为已经不再使用轮询
        // analysisApiClient.stopPolling()
        
        updateState(AnalysisDataManagerState.IDLE)
        println("⏹️ 数据流程已停止 - isRunning=$isRunning")
    }
    
    /**
     * 获取当前状态
     */
    fun getCurrentState(): AnalysisDataManagerState {
        return currentState
    }
    
    /**
     * 获取会话ID
     */
    fun getSessionId(): String {
        return sessionId
    }
    
    /**
     * 是否正在运行
     */
    fun isRunning(): Boolean {
        return isRunning
    }
    
    /**
     * 更新状态
     */
    private fun updateState(newState: AnalysisDataManagerState) {
        if (currentState != newState) {
            currentState = newState
            CoroutineScope(Dispatchers.Main).launch {
                onStateChanged?.invoke(newState)
            }
        }
    }
    
    /**
     * 发送原始NeuroSky数据到分析服务端
     * 直接发送原始设备数据，不进行转换
     */
    fun sendRawDataToServer(rawData: NeuroSkyRawDataPoint) {
        println("🔍 sendRawDataToServer调用 - sessionId='$sessionId', currentState=$currentState")
        
        if (sessionId.isEmpty()) {
            Log.e("AnalysisDataManager", "❌ 会话ID为空，无法发送数据 - sessionId='$sessionId'")
            onError?.invoke("会话ID未初始化，无法发送数据")
            return
        }
        
        // 检查sessionId是否为临时ID（以temp_session开头）
        if (sessionId.startsWith("temp_session")) {
            Log.w("AnalysisDataManager", "⚠️ 检测到临时会话ID，跳过数据发送 - sessionId='$sessionId'")
            return
        }
        
        println("📡 发送原始数据到分析服务端: sessionId=$sessionId, timestamp=${rawData.timestamp}, poorSignal=${rawData.poorSignal}")
        
        // 发送数据到分析服务端
        updateState(AnalysisDataManagerState.SENDING)
        
        analysisApiClient.sendBrainWaveData(
            sessionId = sessionId,
            rawDataPoint = rawData,
            roomId = roomId,
            userId = userId
        )
        
        updateState(AnalysisDataManagerState.PROCESSING)
    }
    
    /**
     * 处理服务端响应数据
     * 直接触发分析结果回调，用于处理已经从服务端获取的分析结果
     */
    fun processServerResponse(response: TabletBrainWaveResponse) {
        println("🔍 AnalysisDataManager.processServerResponse: 处理服务端响应")
        println("🔍 响应数据: success=${response.success}, sleepStage=${response.sleepStage}, confidence=${response.confidence}, frequencyBands=${response.frequencyBands}")
        
        // 直接触发分析结果回调
        onAnalysisResult?.invoke(response)
    }
    
    /**
     * 清理资源
     */
    fun cleanup() {
        stopDataFlow()
        
        // 清理资源
        onDataPointGenerated = null
        onAnalysisResult = null
        onError = null
        onStateChanged = null
        
        println("🧹 AnalysisDataManager资源清理完成")
    }
}